package strategy

import (
	"context"
	"fmt"

	"github.com/gogf/gf/v2/os/gtime"
)

// StrategyStatus 策略状态
type StrategyStatus string

const (
	StatusIdle    StrategyStatus = "idle"    // 空闲
	StatusRunning StrategyStatus = "running" // 运行中
	StatusStopped StrategyStatus = "stopped" // 已停止
	StatusError   StrategyStatus = "error"   // 错误
)

// SignalType 信号类型
type SignalType string

const (
	SignalBuy  SignalType = "buy"  // 买入信号
	SignalSell SignalType = "sell" // 卖出信号
	SignalHold SignalType = "hold" // 持有信号
)

// MarketData 市场数据
type MarketData struct {
	StockCode   string      `json:"stock_code"`   // 股票代码
	Price       float64     `json:"price"`        // 当前价格
	Volume      int64       `json:"volume"`       // 成交量
	Timestamp   *gtime.Time `json:"timestamp"`    // 时间戳
	OpenPrice   float64     `json:"open_price"`   // 开盘价
	HighPrice   float64     `json:"high_price"`   // 最高价
	LowPrice    float64     `json:"low_price"`    // 最低价
	ClosePrice  float64     `json:"close_price"`  // 收盘价
	Change      float64     `json:"change"`       // 涨跌额
	ChangeRatio float64     `json:"change_ratio"` // 涨跌幅
}

// KLineData K线数据
type KLineData struct {
	StockCode   string      `json:"stock_code"`   // 股票代码
	Period      string      `json:"period"`       // 周期(1m,5m,15m,30m,1h,1d)
	Timestamp   *gtime.Time `json:"timestamp"`    // 时间戳
	OpenPrice   float64     `json:"open_price"`   // 开盘价
	HighPrice   float64     `json:"high_price"`   // 最高价
	LowPrice    float64     `json:"low_price"`    // 最低价
	ClosePrice  float64     `json:"close_price"`  // 收盘价
	Volume      int64       `json:"volume"`       // 成交量
	Amount      float64     `json:"amount"`       // 成交额
	Change      float64     `json:"change"`       // 涨跌额
	ChangeRatio float64     `json:"change_ratio"` // 涨跌幅
}

// Signal 交易信号
type Signal struct {
	StrategyID  int         `json:"strategy_id"`  // 策略ID
	StockCode   string      `json:"stock_code"`   // 股票代码
	SignalType  SignalType  `json:"signal_type"`  // 信号类型
	Price       float64     `json:"price"`        // 信号价格
	Quantity    int         `json:"quantity"`     // 数量
	Confidence  float64     `json:"confidence"`   // 信号置信度(0-1)
	Reason      string      `json:"reason"`       // 信号原因
	Timestamp   *gtime.Time `json:"timestamp"`    // 信号时间
	ExtraData   interface{} `json:"extra_data"`   // 额外数据
}

// StrategyConfig 策略配置
type StrategyConfig struct {
	ID          int                    `json:"id"`          // 策略ID
	Name        string                 `json:"name"`        // 策略名称
	Type        string                 `json:"type"`        // 策略类型
	Description string                 `json:"description"` // 策略描述
	Parameters  map[string]interface{} `json:"parameters"`  // 策略参数
	StockPool   []string               `json:"stock_pool"`  // 股票池
	IsActive    bool                   `json:"is_active"`   // 是否激活
	CreatedAt   *gtime.Time            `json:"created_at"`  // 创建时间
	UpdatedAt   *gtime.Time            `json:"updated_at"`  // 更新时间
}

// StrategyContext 策略上下文
type StrategyContext struct {
	Config        *StrategyConfig        `json:"config"`         // 策略配置
	Status        StrategyStatus         `json:"status"`         // 当前状态
	StartTime     *gtime.Time            `json:"start_time"`     // 开始时间
	LastRunTime   *gtime.Time            `json:"last_run_time"`  // 最后运行时间
	RunCount      int64                  `json:"run_count"`      // 运行次数
	ErrorCount    int64                  `json:"error_count"`    // 错误次数
	LastError     string                 `json:"last_error"`     // 最后错误
	Performance   *StrategyPerformance   `json:"performance"`    // 策略性能
	RuntimeData   map[string]interface{} `json:"runtime_data"`   // 运行时数据
	Positions     map[string]*Position   `json:"positions"`      // 持仓信息
}

// StrategyPerformance 策略性能
type StrategyPerformance struct {
	TotalReturn     float64 `json:"total_return"`     // 总收益率
	AnnualReturn    float64 `json:"annual_return"`    // 年化收益率
	SharpeRatio     float64 `json:"sharpe_ratio"`     // 夏普比率
	MaxDrawdown     float64 `json:"max_drawdown"`     // 最大回撤
	WinRate         float64 `json:"win_rate"`         // 胜率
	TotalTrades     int     `json:"total_trades"`     // 总交易次数
	WinTrades       int     `json:"win_trades"`       // 盈利交易次数
	LoseTrades      int     `json:"lose_trades"`      // 亏损交易次数
	AverageWin      float64 `json:"average_win"`      // 平均盈利
	AverageLoss     float64 `json:"average_loss"`     // 平均亏损
	ProfitFactor    float64 `json:"profit_factor"`    // 盈亏比
	UpdatedAt       *gtime.Time `json:"updated_at"`   // 更新时间
}

// Position 持仓信息
type Position struct {
	StockCode     string      `json:"stock_code"`     // 股票代码
	Quantity      int         `json:"quantity"`       // 持仓数量
	AvgPrice      float64     `json:"avg_price"`      // 平均成本
	CurrentPrice  float64     `json:"current_price"`  // 当前价格
	MarketValue   float64     `json:"market_value"`   // 市值
	PnL           float64     `json:"pnl"`            // 盈亏
	PnLRatio      float64     `json:"pnl_ratio"`      // 盈亏比例
	OpenTime      *gtime.Time `json:"open_time"`      // 开仓时间
	LastUpdate    *gtime.Time `json:"last_update"`    // 最后更新时间
}

// Strategy 策略接口
type Strategy interface {
	// GetInfo 获取策略信息
	GetInfo() *StrategyInfo
	
	// Initialize 初始化策略
	Initialize(ctx context.Context, config *StrategyConfig) error
	
	// OnMarketData 处理市场数据
	OnMarketData(ctx context.Context, data *MarketData) ([]*Signal, error)
	
	// OnKLineData 处理K线数据
	OnKLineData(ctx context.Context, kline *KLineData) ([]*Signal, error)
	
	// OnSignal 处理交易信号
	OnSignal(ctx context.Context, signal *Signal) error
	
	// Start 启动策略
	Start(ctx context.Context) error
	
	// Stop 停止策略
	Stop(ctx context.Context) error
	
	// GetStatus 获取策略状态
	GetStatus() StrategyStatus
	
	// GetContext 获取策略上下文
	GetContext() *StrategyContext
	
	// Validate 验证策略配置
	Validate(config *StrategyConfig) error
	
	// OnTimer 定时器回调
	OnTimer(ctx context.Context) error
	
	// OnError 错误处理
	OnError(ctx context.Context, err error)
	
	// Cleanup 清理资源
	Cleanup(ctx context.Context) error
}

// StrategyInfo 策略信息
type StrategyInfo struct {
	Name        string                 `json:"name"`        // 策略名称
	Version     string                 `json:"version"`     // 版本
	Description string                 `json:"description"` // 描述
	Author      string                 `json:"author"`      // 作者
	Parameters  []*ParameterDef        `json:"parameters"`  // 参数定义
	RequiredData []string              `json:"required_data"` // 需要的数据类型
}

// ParameterDef 参数定义
type ParameterDef struct {
	Name         string      `json:"name"`         // 参数名
	Type         string      `json:"type"`         // 参数类型(int,float,string,bool)
	DefaultValue interface{} `json:"default_value"` // 默认值
	MinValue     interface{} `json:"min_value"`    // 最小值
	MaxValue     interface{} `json:"max_value"`    // 最大值
	Description  string      `json:"description"`  // 参数描述
	Required     bool        `json:"required"`     // 是否必需
}

// BaseStrategy 策略基类
type BaseStrategy struct {
	info    *StrategyInfo
	config  *StrategyConfig
	context *StrategyContext
	status  StrategyStatus
}

// NewBaseStrategy 创建策略基类实例
func NewBaseStrategy() *BaseStrategy {
	return &BaseStrategy{
		status: StatusIdle,
		context: &StrategyContext{
			Status:      StatusIdle,
			RunCount:    0,
			ErrorCount:  0,
			RuntimeData: make(map[string]interface{}),
			Positions:   make(map[string]*Position),
			Performance: &StrategyPerformance{},
		},
	}
}

// GetInfo 获取策略信息
func (s *BaseStrategy) GetInfo() *StrategyInfo {
	return s.info
}

// Initialize 初始化策略
func (s *BaseStrategy) Initialize(ctx context.Context, config *StrategyConfig) error {
	s.config = config
	s.context.Config = config
	s.context.Status = StatusIdle
	return nil
}

// Start 启动策略
func (s *BaseStrategy) Start(ctx context.Context) error {
	s.status = StatusRunning
	s.context.Status = StatusRunning
	s.context.StartTime = gtime.Now()
	return nil
}

// Stop 停止策略
func (s *BaseStrategy) Stop(ctx context.Context) error {
	s.status = StatusStopped
	s.context.Status = StatusStopped
	return nil
}

// GetStatus 获取策略状态
func (s *BaseStrategy) GetStatus() StrategyStatus {
	return s.status
}

// GetContext 获取策略上下文
func (s *BaseStrategy) GetContext() *StrategyContext {
	return s.context
}

// Validate 验证策略配置
func (s *BaseStrategy) Validate(config *StrategyConfig) error {
	// 基础验证逻辑
	if config.Name == "" {
		return fmt.Errorf("策略名称不能为空")
	}
	if config.Type == "" {
		return fmt.Errorf("策略类型不能为空")
	}
	return nil
}

// OnTimer 定时器回调
func (s *BaseStrategy) OnTimer(ctx context.Context) error {
	s.context.LastRunTime = gtime.Now()
	s.context.RunCount++
	return nil
}

// OnError 错误处理
func (s *BaseStrategy) OnError(ctx context.Context, err error) {
	s.context.ErrorCount++
	s.context.LastError = err.Error()
	s.status = StatusError
	s.context.Status = StatusError
}

// Cleanup 清理资源
func (s *BaseStrategy) Cleanup(ctx context.Context) error {
	s.status = StatusIdle
	s.context.Status = StatusIdle
	return nil
}

// UpdatePosition 更新持仓信息
func (s *BaseStrategy) UpdatePosition(stockCode string, quantity int, price float64) {
	if position, exists := s.context.Positions[stockCode]; exists {
		// 更新现有持仓
		totalCost := position.AvgPrice*float64(position.Quantity) + price*float64(quantity)
		totalQuantity := position.Quantity + quantity
		if totalQuantity > 0 {
			position.AvgPrice = totalCost / float64(totalQuantity)
			position.Quantity = totalQuantity
		} else {
			// 清仓
			delete(s.context.Positions, stockCode)
		}
	} else if quantity > 0 {
		// 新建持仓
		s.context.Positions[stockCode] = &Position{
			StockCode:    stockCode,
			Quantity:     quantity,
			AvgPrice:     price,
			CurrentPrice: price,
			OpenTime:     gtime.Now(),
			LastUpdate:   gtime.Now(),
		}
	}
}

// GetPosition 获取持仓信息
func (s *BaseStrategy) GetPosition(stockCode string) *Position {
	return s.context.Positions[stockCode]
}

// GetTotalPositions 获取所有持仓
func (s *BaseStrategy) GetTotalPositions() map[string]*Position {
	return s.context.Positions
}

// UpdatePerformance 更新策略性能
func (s *BaseStrategy) UpdatePerformance(performance *StrategyPerformance) {
	s.context.Performance = performance
	s.context.Performance.UpdatedAt = gtime.Now()
}